package execute

import (
	"net/http"
	"sync"
)

var (
	validProxyCache = struct {
		proxy    map[string]proxyInfo
		locker   sync.Mutex
		buffer   []proxyInfo
		maxCount int
	}{
		proxy:    make(map[string]proxyInfo),
		maxCount: 900000,
	}
	notifyChan     = make(chan struct{}, 256)
	validProxyOnce = sync.Once{}
)

type proxyInfo struct {
	str       string
	rt        http.RoundTripper
	usedCount int
}

func getProxyCount() int {
	validProxyCache.locker.Lock()
	defer validProxyCache.locker.Unlock()

	return len(validProxyCache.proxy)
}

func getProxy() proxyInfo {

	validProxyCache.locker.Lock()
	defer validProxyCache.locker.Unlock()

	var r = proxyInfo{}
	if len(validProxyCache.proxy) == 0 {
		return r
	}

	for _, v := range validProxyCache.proxy {
		r = v
		break
	}

	return r
}

//
//func setProxy(str string, rt http.RoundTripper) {
//
//	validProxyCache.locker.Lock()
//	defer validProxyCache.locker.Unlock()
//
//	validProxyCache.buffer = append(validProxyCache.buffer, proxyInfo{
//		str: str,
//		rt:  rt,
//	})
//
//	validProxyOnce.Do(func() {
//
//		for range notifyChan {
//			validProxyCache.locker.Lock()
//
//			for _, buffer := range validProxyCache.buffer {
//				if _, ok := validProxyCache.proxy[buffer.str]; ok {
//					continue
//				}
//
//				if len(validProxyCache.proxy) > validProxyCache.maxCount {
//					for k, _ := range validProxyCache.proxy {
//						delete(validProxyCache.proxy, k)
//						break
//					}
//				}
//
//				validProxyCache.proxy[str] = buffer
//			}
//
//			validProxyCache.buffer = validProxyCache.buffer[:0]
//			validProxyCache.locker.Unlock()
//		}
//	})
//
//	if len(validProxyCache.buffer) >= 200 || (len(validProxyCache.proxy) == 0 && len(validProxyCache.buffer) > 0) {
//		select {
//		case notifyChan <- struct{}{}:
//			break
//		default:
//			break
//		}
//	}
//	return
//}

func setProxy(str string, rt http.RoundTripper) {

	validProxyCache.locker.Lock()
	defer validProxyCache.locker.Unlock()

	if _, ok := validProxyCache.proxy[str]; ok {
		return
	}

	if len(validProxyCache.proxy) > validProxyCache.maxCount {
		for k, _ := range validProxyCache.proxy {
			delete(validProxyCache.proxy, k)
			break
		}
	}

	validProxyCache.proxy[str] = proxyInfo{
		str: str,
		rt:  rt,
	}

	return
}

func delProxy(str string) {

	validProxyCache.locker.Lock()
	defer validProxyCache.locker.Unlock()

	delete(validProxyCache.proxy, str)
	return
}
